जावास्क्रिप्ट समवर्ती प्राथमिकता कतार: थ्रेड-सुरक्षित प्राथमिकता प्रबंधन

आधुनिक जावास्क्रिप्ट विकास में, विशेष रूप से Node.js और वेब वर्कर्स जैसे वातावरणों में, समवर्ती संचालनों का कुशलतापूर्वक प्रबंधन करना महत्वपूर्ण है। एक प्राथमिकता कतार (priority queue) एक मूल्यवान डेटा संरचना है जो आपको कार्यों को उनकी निर्दिष्ट प्राथमिकता के आधार पर संसाधित करने की अनुमति देती है। जब समवर्ती वातावरणों से निपटना होता है, तो यह सुनिश्चित करना कि यह प्राथमिकता प्रबंधन थ्रेड-सुरक्षित हो, सर्वोपरि हो जाता है। यह ब्लॉग पोस्ट जावास्क्रिप्ट में एक समवर्ती प्राथमिकता कतार की अवधारणा में गहराई से उतरेगा, इसके कार्यान्वयन, फायदे और उपयोग के मामलों की खोज करेगा। हम जांच करेंगे कि एक थ्रेड-सुरक्षित प्राथमिकता कतार कैसे बनाई जाए जो गारंटीकृत प्राथमिकता के साथ एसिंक्रोनस संचालन को संभाल सके।

प्राथमिकता कतार क्या है?

एक प्राथमिकता कतार एक अमूर्त डेटा प्रकार है जो एक नियमित कतार या स्टैक के समान है, लेकिन इसमें एक अतिरिक्त मोड़ है: कतार में प्रत्येक तत्व के साथ एक प्राथमिकता जुड़ी होती है। जब किसी तत्व को डीक्यू किया जाता है, तो उच्चतम प्राथमिकता वाले तत्व को पहले हटाया जाता है। यह एक नियमित कतार (FIFO - फर्स्ट-इन, फर्स्ट-आउट) और एक स्टैक (LIFO - लास्ट-इन, फर्स्ट-आउट) से अलग है।

इसे एक अस्पताल के आपातकालीन कक्ष की तरह सोचें। मरीजों का इलाज उनके आने के क्रम में नहीं किया जाता है; इसके बजाय, सबसे गंभीर मामलों को पहले देखा जाता है, भले ही उनके आने का समय कुछ भी हो। यह 'गंभीरता' ही उनकी प्राथमिकता है।

प्राथमिकता कतार की मुख्य विशेषताएं:

• प्राथमिकता निर्धारण: प्रत्येक तत्व को एक प्राथमिकता सौंपी जाती है।
• क्रमबद्ध डीक्यू: तत्वों को प्राथमिकता के आधार पर डीक्यू किया जाता है (उच्चतम प्राथमिकता पहले)।
• गतिशील समायोजन: कुछ कार्यान्वयनों में, किसी तत्व को कतार में जोड़े जाने के बाद उसकी प्राथमिकता को बदला जा सकता है।

उदाहरण परिदृश्य जहां प्राथमिकता कतारें उपयोगी हैं:

• कार्य निर्धारण (Task Scheduling): एक ऑपरेटिंग सिस्टम में महत्व या तात्कालिकता के आधार पर कार्यों को प्राथमिकता देना।
• इवेंट हैंडलिंग (Event Handling): एक GUI एप्लिकेशन में इवेंट्स का प्रबंधन करना, कम महत्वपूर्ण इवेंट्स से पहले महत्वपूर्ण इवेंट्स को संसाधित करना।
• रूटिंग एल्गोरिदम (Routing Algorithms): एक नेटवर्क में सबसे छोटा रास्ता खोजना, लागत या दूरी के आधार पर मार्गों को प्राथमिकता देना।
• सिमुलेशन (Simulation): वास्तविक दुनिया के परिदृश्यों का अनुकरण करना जहां कुछ घटनाओं की प्राथमिकता दूसरों की तुलना में अधिक होती है (जैसे, आपातकालीन प्रतिक्रिया सिमुलेशन)।
• वेब सर्वर अनुरोध हैंडलिंग (Web Server Request Handling): उपयोगकर्ता प्रकार (जैसे, भुगतान करने वाले ग्राहक बनाम मुफ्त उपयोगकर्ता) या अनुरोध प्रकार (जैसे, महत्वपूर्ण सिस्टम अपडेट बनाम पृष्ठभूमि डेटा सिंक्रनाइज़ेशन) के आधार पर API अनुरोधों को प्राथमिकता देना।

समरूपता की चुनौती

जावास्क्रिप्ट, अपनी प्रकृति से, सिंगल-थ्रेडेड है। इसका मतलब है कि यह एक समय में केवल एक ही ऑपरेशन निष्पादित कर सकता है। हालांकि, जावास्क्रिप्ट की एसिंक्रोनस क्षमताएं, विशेष रूप से Promises, async/await, और वेब वर्कर्स के उपयोग के माध्यम से, हमें समरूपता का अनुकरण करने और एक साथ कई कार्य करने की अनुमति देती हैं।

समस्या: रेस कंडीशंस (Race Conditions)

जब कई थ्रेड्स या एसिंक्रोनस ऑपरेशन एक साथ साझा डेटा (हमारे मामले में, प्राथमिकता कतार) तक पहुंचने और संशोधित करने का प्रयास करते हैं, तो रेस कंडीशंस हो सकती हैं। एक रेस कंडीशन तब होती है जब निष्पादन का परिणाम उस अप्रत्याशित क्रम पर निर्भर करता है जिसमें ऑपरेशन निष्पादित होते हैं। इससे डेटा भ्रष्टाचार, गलत परिणाम और अप्रत्याशित व्यवहार हो सकता है।

उदाहरण के लिए, कल्पना करें कि दो थ्रेड एक ही समय में एक ही प्राथमिकता कतार से तत्वों को डीक्यू करने का प्रयास कर रहे हैं। यदि दोनों थ्रेड कतार की स्थिति को पढ़ने से पहले उसे अपडेट कर देते हैं, तो वे दोनों एक ही तत्व को उच्चतम प्राथमिकता के रूप में पहचान सकते हैं, जिससे एक तत्व छूट सकता है या कई बार संसाधित हो सकता है, जबकि अन्य तत्व बिल्कुल भी संसाधित नहीं हो सकते हैं।

थ्रेड सुरक्षा क्यों मायने रखती है

थ्रेड सुरक्षा यह सुनिश्चित करती है कि एक डेटा संरचना या कोड ब्लॉक को कई थ्रेड्स द्वारा एक साथ एक्सेस और संशोधित किया जा सकता है, बिना डेटा भ्रष्टाचार या असंगत परिणामों के। प्राथमिकता कतार के संदर्भ में, थ्रेड सुरक्षा गारंटी देती है कि तत्वों को सही क्रम में एनक्यू और डीक्यू किया जाता है, उनकी प्राथमिकताओं का सम्मान करते हुए, भले ही कई थ्रेड्स एक साथ कतार तक पहुंच रहे हों।

जावास्क्रिप्ट में एक समवर्ती प्राथमिकता कतार का कार्यान्वयन

जावास्क्रिप्ट में एक थ्रेड-सुरक्षित प्राथमिकता कतार बनाने के लिए, हमें संभावित रेस कंडीशंस को संबोधित करने की आवश्यकता है। हम इसे विभिन्न तकनीकों का उपयोग करके पूरा कर सकते हैं, जिनमें शामिल हैं:

1. लॉक्स (म्यूटेक्स): कोड के महत्वपूर्ण वर्गों की सुरक्षा के लिए लॉक्स का उपयोग करना, यह सुनिश्चित करना कि एक समय में केवल एक ही थ्रेड कतार तक पहुंच सकता है।
2. एटॉमिक ऑपरेशंस: सरल डेटा संशोधनों के लिए एटॉमिक ऑपरेशंस का उपयोग करना, यह सुनिश्चित करना कि ऑपरेशन अविभाज्य हैं और बाधित नहीं किए जा सकते हैं।
3. अपरिवर्तनीय डेटा संरचनाएं: अपरिवर्तनीय डेटा संरचनाओं का उपयोग करना, जहां संशोधन मूल डेटा को संशोधित करने के बजाय नई प्रतियां बनाते हैं। यह लॉकिंग की आवश्यकता से बचाता है लेकिन लगातार अपडेट के साथ बड़ी कतारों के लिए कम कुशल हो सकता है।
4. संदेश पासिंग: संदेशों का उपयोग करके थ्रेड्स के बीच संचार करना, सीधे साझा मेमोरी एक्सेस से बचना और रेस कंडीशंस के जोखिम को कम करना।

म्यूटेक्स (लॉक्स) का उपयोग करके उदाहरण कार्यान्वयन

यह उदाहरण प्राथमिकता कतार के महत्वपूर्ण वर्गों की सुरक्षा के लिए म्यूटेक्स (म्यूचुअल एक्सक्लूजन लॉक) का उपयोग करके एक बुनियादी कार्यान्वयन प्रदर्शित करता है। एक वास्तविक दुनिया के कार्यान्वयन में अधिक मजबूत त्रुटि प्रबंधन और अनुकूलन की आवश्यकता हो सकती है।

सबसे पहले, आइए एक सरल `Mutex` क्लास को परिभाषित करें:

class Mutex {
  constructor() {
    this.locked = false;
    this.queue = [];
  }

  lock() {
    return new Promise((resolve) => {
      if (!this.locked) {
        this.locked = true;
        resolve();
      } else {
        this.queue.push(resolve);
      }
    });
  }

  unlock() {
    if (this.queue.length > 0) {
      const nextResolve = this.queue.shift();
      nextResolve();
    } else {
      this.locked = false;
    }
  }
}

अब, आइए `ConcurrentPriorityQueue` क्लास को लागू करें:

class ConcurrentPriorityQueue {
  constructor() {
    this.queue = [];
    this.mutex = new Mutex();
  }

  async enqueue(element, priority) {
    await this.mutex.lock();
    try {
      this.queue.push({ element, priority });
      this.queue.sort((a, b) => b.priority - a.priority); // Higher priority first
    } finally {
      this.mutex.unlock();
    }
  }

  async dequeue() {
    await this.mutex.lock();
    try {
      if (this.queue.length === 0) {
        return null; // Or throw an error
      }
      return this.queue.shift().element;
    } finally {
      this.mutex.unlock();
    }
  }

  async peek() {
    await this.mutex.lock();
    try {
      if (this.queue.length === 0) {
        return null; // Or throw an error
      }
      return this.queue[0].element;
    } finally {
      this.mutex.unlock();
    }
  }

  async isEmpty() {
        await this.mutex.lock();
        try {
            return this.queue.length === 0;
        } finally {
            this.mutex.unlock();
        }
    }

  async size() {
    await this.mutex.lock();
    try {
      return this.queue.length;
    } finally {
      this.mutex.unlock();
    }
  }
}

स्पष्टीकरण:

• `Mutex` क्लास एक सरल म्यूचुअल एक्सक्लूजन लॉक प्रदान करती है। `lock()` विधि लॉक प्राप्त करती है, यदि यह पहले से ही रखा गया है तो प्रतीक्षा करती है। `unlock()` विधि लॉक को छोड़ देती है, जिससे दूसरे प्रतीक्षा कर रहे थ्रेड को इसे प्राप्त करने की अनुमति मिलती है।
• `ConcurrentPriorityQueue` क्लास `enqueue()` और `dequeue()` विधियों की सुरक्षा के लिए `Mutex` का उपयोग करती है।
• `enqueue()` विधि एक तत्व को उसकी प्राथमिकता के साथ कतार में जोड़ती है और फिर प्राथमिकता क्रम बनाए रखने के लिए कतार को सॉर्ट करती है (उच्चतम प्राथमिकता पहले)।
• `dequeue()` विधि उच्चतम प्राथमिकता वाले तत्व को हटाती है और लौटाती है।
• `peek()` विधि उच्चतम प्राथमिकता वाले तत्व को बिना हटाए लौटाती है।
• `isEmpty()` विधि जांचती है कि कतार खाली है या नहीं।
• `size()` विधि कतार में तत्वों की संख्या लौटाती है।
• प्रत्येक विधि में `finally` ब्लॉक यह सुनिश्चित करता है कि म्यूटेक्स हमेशा अनलॉक हो, भले ही कोई त्रुटि हो।

उपयोग का उदाहरण:

asyn